home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dutil / hunks.c < prev    next >
C/C++ Source or Header  |  1997-09-09  |  6KB  |  294 lines
  1. /*
  2.  *    (c)Copyright 1992-1997 Obvious Implementations Corp.  Redistribution and
  3.  *    use is allowed under the terms of the DICE-LICENSE FILE,
  4.  *    DICE-LICENSE.TXT.
  5.  */
  6.  
  7. /*
  8.  *  HUNKS.C
  9.  *
  10.  *  HUNKS executable
  11.  *
  12.  */
  13.  
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  17.  
  18. #ifdef AMIGA
  19. #include <lib/version.h>
  20. #else
  21. #include <include/lib/version.h>
  22. #include <suplib/all.h>
  23. #define __aligned
  24. #endif
  25.  
  26. IDENT("hunks",".3");
  27. DCOPYRIGHT;
  28.  
  29. typedef unsigned char ubyte;
  30. typedef unsigned short uword;
  31. typedef unsigned long ulong;
  32.  
  33. void DumpHunks(char *);
  34. ulong fgetl(FILE *);
  35. void fgetname(FILE *, char *, long);
  36. void zfseek(FILE *, long);
  37.  
  38. short AllOpt;
  39.  
  40. int
  41. main(int ac, char **av)
  42. {
  43.     short i;
  44.  
  45. #ifndef unix
  46.     expand_args(ac, av, &ac, &av);
  47. #endif
  48.  
  49.     if (ac == 1) {
  50.     printf("%s\n%s\n", Ident, DCopyright);
  51.     puts("hunks [-all] executeable/object_module");
  52.     exit(0);
  53.     }
  54.     for (i = 1; i < ac; ++i) {
  55.     char *ptr = av[i];
  56.  
  57.     if (*ptr != '-') {
  58.         printf("\n** FILE %s **\n\n", ptr);
  59.         DumpHunks(ptr);
  60.         continue;
  61.     }
  62.     if (stricmp(ptr, "-all") == 0)
  63.         AllOpt = 1;
  64.     }
  65.     return(0);
  66. }
  67.  
  68. void
  69. DumpHunks(fileName)
  70. char *fileName;
  71. {
  72.     FILE *fi;
  73.     __aligned char buf[256];
  74.  
  75.     if ((fi = fopen(fileName, "r")) != NULL) {
  76.     ulong type;
  77.     ulong flags;
  78.     ulong skip;
  79.     ulong n;
  80.  
  81.     while ((type = fgetl(fi)) != 0) {
  82.         skip = 0;
  83.  
  84.         flags = type & 0xFFFF0000;
  85.         type  = type & 0x0000FFFF;
  86.  
  87.         switch(type) {
  88.         case 0x3F3:         /*    HUNK_HEADER */
  89.         {
  90.             long hno;
  91.  
  92.             n = fgetl(fi);
  93.             fgetname(fi, buf, n);
  94.             skip = fgetl(fi);
  95.             printf("%08x HUNK_HEADER\tname=%s\tsize=%ld ", 0x3F3, buf, skip);
  96.             printf("first=%ld ", (hno = fgetl(fi)));
  97.             printf("last=%ld\n", fgetl(fi));
  98.  
  99.             while (skip) {
  100.             --skip;
  101.             n = fgetl(fi);
  102.             printf("    %08lx HUNK %ld SIZE %ld", n, hno, (n & 0x00FFFFFF) * 4);
  103.             switch(n & 0xC0000000) {
  104.             case 0x00000000:
  105.                 break;
  106.             case 0x40000000:
  107.                 printf(" MEMF_CHIP");
  108.                 break;
  109.             case 0x80000000:
  110.                 printf(" MEMF_FAST");
  111.                 break;
  112.             case 0xC0000000:
  113.                 printf(" MEMF_CHIP|MEMF_FAST");
  114.                 break;
  115.             }
  116.             puts("");
  117.             ++hno;
  118.             }
  119.         }
  120.         break;
  121.         case 0x3E9:         /*    HUNK_CODE   */
  122.         skip = fgetl(fi);
  123.         printf("%08lx HUNK_CODE\tsize=%ld\n", type, skip * 4);
  124.         break;
  125.         case 0x3EA:         /*    HUNK_DATA    */
  126.         skip = fgetl(fi);
  127.         printf("%08lx HUNK_DATA\tsize=%ld\n", type, skip * 4);
  128.         break;
  129.         break;
  130.         case 0x3EB:         /*    HUNK_BSS    */
  131.         skip = fgetl(fi);
  132.         printf("%08lx HUNK_BSS\tsize=%ld\n", type, skip * 4);
  133.         skip = 0;
  134.         break;
  135.         case 0x3EC:         /*    HUNK_RELOC32    */
  136.         printf("%08lx HUNK_RELOC-ABSOLUTE32\n", type);
  137.         case 0x3ED:         /*    HUNK_RELOC16-PC */
  138.         if (type == 0x3ED)
  139.             printf("%08lx HUNK_RELOC-PCREL16\n", type);
  140.         case 0x3EE:         /*    HUNK_RELOC8    */
  141.         if (type == 0x3EE)
  142.             printf("%08lx HUNK_RELOC-PCREL8\n", type);
  143.         case 0x3F8:         /*    HUNK_RELOC16-D    (special) */
  144.         if (type == 0x3F8)
  145.             printf("%08lx HUNK_RELOC-DATAREL16\n", type);
  146.         while ((skip = fgetl(fi)) != 0) {
  147.             n = fgetl(fi);
  148.             printf("    %ld relocations to hunk %ld\n", skip, n);
  149.             if (AllOpt) {
  150.             while (skip) {
  151.                 --skip;
  152.                 n = fgetl(fi);
  153.                 printf("\t@0x%08lx\n", n);
  154.             }
  155.             } else {
  156.             zfseek(fi, skip);
  157.             }
  158.         }
  159.         break;
  160.         case 0x3EF:         /*    HUNK_EXT    */
  161.         printf("%08lx HUNK_EXT\n", type);
  162.         case 0x3F0:         /*    HUNK_SYMBOL    */
  163.         if (type == 0x3F0)
  164.             printf("%08lx HUNK_SYMBOL\n", type);
  165.         while ((skip = fgetl(fi)) != 0) {
  166.             ubyte symType = skip >> 24;
  167.  
  168.             skip &= 0x00FFFFFF;
  169.             fgetname(fi, buf, skip);
  170.             printf("    0x%02x:%-15s", symType, buf);
  171.  
  172.             switch(symType) {
  173.             case 0:        /*    SYMB    */
  174.             printf("\tSYMBOL");
  175.             case 1:        /*    DEF    */
  176.             if (symType == 1)
  177.                 printf("\tXDEF");
  178.             case 2:        /*    ABS    */
  179.             if (symType == 2)
  180.                 printf("\tABS-SYM");
  181.             case 3:        /*    RES    */
  182.             if (symType == 3)
  183.                 printf("\tRES-SYM");
  184.             n = fgetl(fi);
  185.             printf("\tval=0x%08lx", n);
  186.             break;
  187.             case 130:        /*    COMMON (def)*/
  188.             n = fgetl(fi);
  189.             printf("\tCOMMON size=0x%04lx", n);
  190.             break;
  191.             case 135:        /*    REF32-pc    */
  192.             printf("\tPCREL-32");
  193.             case 129:        /*    REF32        */
  194.             if (symType == 129)
  195.                 printf("\tABSOLUTE-32");
  196.             case 131:        /*    REF16-pc    */
  197.             if (symType == 131)
  198.                 printf("\tPCREL-16");
  199.             case 132:        /*    REF8        */
  200.             if (symType == 132)
  201.                 printf("\tPCREL-8");
  202.             case 134:        /*    REF16D        */
  203.             if (symType == 134)
  204.                 printf("\tDATAREL-16");
  205.             n = fgetl(fi);
  206.             printf("\t%ld relocs", n);
  207.             zfseek(fi, n);
  208.             break;
  209.             default:
  210.             printf("\tUNKNOWN TYPE FIELD");
  211.             }
  212.             puts("");
  213.         }
  214.         break;
  215.         case 0x3F1:         /*    HUNK_DEBUG        */
  216.         skip = fgetl(fi);
  217.         printf("%08lx HUNK_DEBUG\t%ld bytes\n", type, skip * 4);
  218.         break;
  219.         case 0x3E8:
  220.         n = fgetl(fi);
  221.         fgetname(fi, buf, n);
  222.         printf("%08lx HUNK_NAME\tname=%s\n", type, buf);
  223.         break;
  224.         case 0x3E7:
  225.         n = fgetl(fi);
  226.         fgetname(fi, buf, n);
  227.         printf("%08lx HUNK_UNIT\tname=%s\n", type, buf);
  228.         break;
  229.         case 0x3F2:
  230.         printf("%08lx HUNK_END\n\n", type);
  231.         break;
  232.         default:
  233.         printf("%08lx UNKNOWN HUNK TYPE\n", type);
  234.         break;
  235.         }
  236.         if (skip)
  237.         zfseek(fi, skip);
  238.     }
  239.     }
  240. }
  241.  
  242. ulong
  243. fgetl(fi)
  244. FILE *fi;
  245. {
  246.     ulong n;
  247.     short c;
  248.  
  249.     if ((c = getc(fi)) != EOF) {
  250.     n = c << 24;
  251.     if ((c = getc(fi)) != EOF) {
  252.         n |= c << 16;
  253.         if ((c = getc(fi)) != EOF) {
  254.         n |= c << 8;
  255.         if ((c = getc(fi)) != EOF) {
  256.             n |= c;
  257.             return(FromMsbOrder(n));
  258.         }
  259.         }
  260.     }
  261.     }
  262.     return(0);
  263. }
  264.  
  265. void
  266. fgetname(fi, buf, len)
  267. FILE *fi;
  268. char *buf;
  269. long len;
  270. {
  271.     long n;
  272.  
  273.     for (n = 0; n < len && n < 255/4; ++n) {
  274.     *((long *)buf + n) = ToMsbOrder(fgetl(fi));
  275.     }
  276.     *((long *)buf + n) = ToMsbOrder(0);
  277. }
  278.  
  279. void
  280. zfseek(fi, numLongs)
  281. FILE *fi;
  282. long numLongs;
  283. {
  284.     if (numLongs < 32) {
  285.     while (numLongs) {
  286.         --numLongs;
  287.         fgetl(fi);
  288.     }
  289.     } else {
  290.     fseek(fi, numLongs * 4, 1);
  291.     }
  292. }
  293.  
  294.